Bridging the Gap: Byzantine Faults and Self-stabilization

Distributed systems are everywhere. As everyday lives become more and more dependent on distributed systems, they are expected to withstand different kinds of failures. Different models of failures exist which aim at modeling network errors, hardware failures, soft errors, etc. This thesis concentrates on dealing with a combination of two different kinds of fault tolerance. The Byzantine failure model aims at modeling hardware failures. A system is said to be tolerant to Byzantine failures if it can withstand any arbitrary behavior of (usually) up to a constant percentage of its nodes. That is, a constant percentage of the nodes may behave in any way and may collude together to try and prevent the system from operating correctly. Clearly, if a system is Byzantine tolerant then it will be able to overcome hardware failures, as long as enough nodes operate correctly. The self-stabilizing failure model aims at modeling soft errors. A system is said to be self-stabilizing if starting from any memory state, it will eventually converge to an operating condition. For example, a self-stabilizing clock synchronization will eventually (even if it is started when different nodes are out of sync) have all nodes in the system agree on the same time. If a system is self-stabilizing and a soft error occurred, then eventually (if there are no more soft errors) it will converge to an operational state. Combining self-stabilizing and Byzantine failures is a challenging task. It requires the algorithm to tolerate both external errors (i.e., neighboring nodes which are Byzantine) and internal errors (i.e., soft errors which may lead to an arbitrary memory state). However, an algorithm that is both selfstabilizing and Byzantine tolerant has highly desired robust properties: Even if the assumed working conditions are invalidated, when they are eventually re-guaranteed the algorithm will converge to an operating state. Three different problems are discussed herein. First, the self-stabilizing Byzantine tolerant clock synchronization problem; in which the system may start in any arbitrary state, and eventually (in the ongoing presence of Byzantine nodes) all nodes should agree on the same clock value, and increase it regularly. Two different solutions to this problem are given. One operates in a synchronous network and provides an expected constant convergence rate; while the other operates in a semi-synchronous (sometimes denoted “bounded-delay”) network and provides a (deterministic) linear convergence time. Second, the stability of a system’s output is investigated. Specifically,